package com.qsw.qswcommonlib.util;

import android.graphics.Typeface;
import android.text.Spannable;
import android.text.SpannableStringBuilder;
import android.text.TextUtils;
import android.text.style.AbsoluteSizeSpan;
import android.text.style.BackgroundColorSpan;
import android.text.style.CharacterStyle;
import android.text.style.ForegroundColorSpan;
import android.text.style.StrikethroughSpan;
import android.text.style.StyleSpan;
import android.text.style.UnderlineSpan;

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * TextView指定位置或字段设置指定颜色
 */
public class CommonStrStyleUtil {

    /**
     * 字符串样式类型
     */
    public enum StrStyleType {
        STR_COLOR, // 文字颜色
        STR_BG_COLOR, // 文字背景色
        STR_SIZE, // 文字字号
        STR_BOLD, // 加粗
        STR_ITALIC,// 斜体
        STR_BOLD_ITALIC, // 加粗和斜体
        STR_STRIKETHROUGH, // 删除线
        STR_UNDERLINE// 下划线
    }

    /**
     * 单个关键字
     * 设置在wholeStr中第一次出现的keyStr的颜色
     *
     * @param wholeStr    全部文字
     * @param keyStr      关键字
     * @param keyStrColor 关键字的颜色
     * @param matchCase   true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrColorFirst(String wholeStr, String keyStr, int keyStrColor, boolean matchCase) {
        return fillStrColorFirst(new SpannableStringBuilder(wholeStr), keyStr, keyStrColor, matchCase);
    }

    /**
     * 单个关键字
     * 设置在spannableStringBuilder中第一次出现的keyStr的颜色
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStr                 关键字
     * @param keyStrColor            关键字的颜色
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrColorFirst(SpannableStringBuilder spannableStringBuilder, String keyStr
            , int keyStrColor, boolean matchCase) {
        return fillStrStyleFirst(spannableStringBuilder, keyStr, keyStrColor, StrStyleType.STR_COLOR, matchCase);
    }

    /**
     * 单个关键字
     * 设置在wholeStr中第一次出现的keyStr的背景颜色
     *
     * @param wholeStr    全部文字
     * @param keyStr      关键字
     * @param keyStrColor 关键字的背景颜色
     * @param matchCase   true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrBgColorFirst(String wholeStr, String keyStr, int keyStrColor, boolean matchCase) {
        return fillStrBgColorFirst(new SpannableStringBuilder(wholeStr), keyStr, keyStrColor, matchCase);
    }

    /**
     * 单个关键字
     * 设置在spannableStringBuilder中第一次出现的keyStr的背景颜色
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStr                 关键字
     * @param keyStrColor            关键字的背景颜色
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrBgColorFirst(SpannableStringBuilder spannableStringBuilder, String keyStr
            , int keyStrColor, boolean matchCase) {
        return fillStrStyleFirst(spannableStringBuilder, keyStr, keyStrColor, StrStyleType.STR_BG_COLOR, matchCase);
    }

    /**
     * 单个关键字
     * 设置在wholeStr中第一次出现的keyStr的字号
     *
     * @param wholeStr   全部文字
     * @param keyStr     关键字
     * @param keyStrSize 关键字的字号，单位pixels
     * @param matchCase  true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrSizeFirst(String wholeStr, String keyStr, int keyStrSize, boolean matchCase) {
        return fillStrSizeFirst(new SpannableStringBuilder(wholeStr), keyStr, keyStrSize, matchCase);
    }

    /**
     * 单个关键字
     * 设置在spannableStringBuilder中第一次出现的keyStr的字号
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStr                 关键字
     * @param keyStrSize             关键字的字号，单位pixels
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrSizeFirst(SpannableStringBuilder spannableStringBuilder, String keyStr
            , int keyStrSize, boolean matchCase) {
        return fillStrStyleFirst(spannableStringBuilder, keyStr, keyStrSize, StrStyleType.STR_SIZE, matchCase);
    }

    /**
     * 单个关键字
     * 设置在wholeStr中第一次出现的keyStr的样式
     *
     * @param wholeStr     全部文字
     * @param keyStr       关键字
     * @param keyStrValue  关键字值
     * @param strStyleType 字符串样式类型
     * @param matchCase    true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrStyleFirst(String wholeStr, String keyStr, int keyStrValue
            , StrStyleType strStyleType, boolean matchCase) {
        return fillStrStyleFirst(new SpannableStringBuilder(wholeStr), keyStr, keyStrValue, strStyleType, matchCase);
    }

    /**
     * 单个关键字
     * 设置在spannableStringBuilder中第一次出现的keyStr的样式
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStr                 关键字
     * @param keyStrValue            关键字值
     * @param strStyleType           字符串样式类型
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrStyleFirst(SpannableStringBuilder spannableStringBuilder, String keyStr
            , int keyStrValue, StrStyleType strStyleType, boolean matchCase) {
        if (spannableStringBuilder == null) {
            return null;
        }
        String wholeStr = spannableStringBuilder.toString();
        if (!TextUtils.isEmpty(wholeStr) && !TextUtils.isEmpty(keyStr) && strStyleType != null) {
            if (!matchCase) {
                wholeStr = wholeStr.toLowerCase();
                keyStr = keyStr.toLowerCase();
            }
            if (wholeStr.contains(keyStr)) {
                int start = wholeStr.indexOf(keyStr);
                int end = start + keyStr.length();
                CharacterStyle characterStyle = null;
                switch (strStyleType) {
                    case STR_COLOR:
                        characterStyle = new ForegroundColorSpan(keyStrValue);
                        break;
                    case STR_BG_COLOR:
                        characterStyle = new BackgroundColorSpan(keyStrValue);
                        break;
                    case STR_SIZE:
                        characterStyle = new AbsoluteSizeSpan(keyStrValue);
                        break;
                    case STR_BOLD:
                        characterStyle = new StyleSpan(Typeface.BOLD);
                        break;
                    case STR_ITALIC:
                        characterStyle = new StyleSpan(Typeface.ITALIC);
                        break;
                    case STR_BOLD_ITALIC:
                        characterStyle = new StyleSpan(Typeface.BOLD_ITALIC);
                        break;
                    case STR_STRIKETHROUGH:
                        characterStyle = new StrikethroughSpan();
                        break;
                    case STR_UNDERLINE:
                        characterStyle = new UnderlineSpan();
                        break;
                }
                if (characterStyle != null) {
                    spannableStringBuilder.setSpan(characterStyle, start, end, Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
                }
            }
        }
        return spannableStringBuilder;
    }

    /**
     * 单个关键字
     * 设置在wholeStr中出现的所有keyStr的颜色
     *
     * @param wholeStr    全部文字
     * @param keyStr      关键字
     * @param keyStrColor 关键字的颜色
     * @param matchCase   true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrColorAll(String wholeStr, String keyStr, int keyStrColor, boolean matchCase) {
        return fillStrColorAll(new SpannableStringBuilder(wholeStr), keyStr, keyStrColor, matchCase);
    }

    /**
     * 单个关键字
     * 设置在spannableStringBuilder中出现的所有keyStr的颜色
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStr                 关键字
     * @param keyStrColor            关键字的颜色
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrColorAll(SpannableStringBuilder spannableStringBuilder, String keyStr
            , int keyStrColor, boolean matchCase) {
        return fillStrStyleAll(spannableStringBuilder, keyStr, keyStrColor, StrStyleType.STR_COLOR, matchCase);
    }

    /**
     * 单个关键字
     * 设置在wholeStr中出现的所有keyStr的背景颜色
     *
     * @param wholeStr    全部文字
     * @param keyStr      关键字
     * @param keyStrColor 关键字的背景颜色
     * @param matchCase   true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrBgColorAll(String wholeStr, String keyStr, int keyStrColor, boolean matchCase) {
        return fillStrBgColorAll(new SpannableStringBuilder(wholeStr), keyStr, keyStrColor, matchCase);
    }

    /**
     * 单个关键字
     * 设置在spannableStringBuilder中出现的所有keyStr的背景颜色
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStr                 关键字
     * @param keyStrColor            关键字的背景颜色
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrBgColorAll(SpannableStringBuilder spannableStringBuilder, String keyStr
            , int keyStrColor, boolean matchCase) {
        return fillStrStyleAll(spannableStringBuilder, keyStr, keyStrColor, StrStyleType.STR_BG_COLOR, matchCase);
    }

    /**
     * 单个关键字
     * 设置在wholeStr中出现的所有keyStr的字号
     *
     * @param wholeStr   全部文字
     * @param keyStr     关键字
     * @param keyStrSize 关键字的字号，单位pixels
     * @param matchCase  true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrSizeAll(String wholeStr, String keyStr, int keyStrSize, boolean matchCase) {
        return fillStrSizeAll(new SpannableStringBuilder(wholeStr), keyStr, keyStrSize, matchCase);
    }

    /**
     * 单个关键字
     * 设置在spannableStringBuilder中出现的所有keyStr的字号
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStr                 关键字
     * @param keyStrSize             关键字的字号，单位pixels
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrSizeAll(SpannableStringBuilder spannableStringBuilder, String keyStr
            , int keyStrSize, boolean matchCase) {
        return fillStrStyleAll(spannableStringBuilder, keyStr, keyStrSize, StrStyleType.STR_SIZE, matchCase);
    }

    /**
     * 单个关键字
     * 设置在wholeStr中出现的所有keyStr的样式
     *
     * @param wholeStr     全部文字
     * @param keyStr       关键字
     * @param keyStrValue  关键字值
     * @param strStyleType 字符串样式类型
     * @param matchCase    true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrStyleAll(String wholeStr, String keyStr, int keyStrValue
            , StrStyleType strStyleType, boolean matchCase) {
        return fillStrStyleAll(new SpannableStringBuilder(wholeStr), keyStr, keyStrValue, strStyleType, matchCase);
    }

    /**
     * 单个关键字
     * 设置在spannableStringBuilder中出现的所有keyStr的样式
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStr                 关键字
     * @param keyStrValue            关键字值
     * @param strStyleType           字符串样式类型
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrStyleAll(SpannableStringBuilder spannableStringBuilder, String keyStr
            , int keyStrValue, StrStyleType strStyleType, boolean matchCase) {
        if (spannableStringBuilder == null) {
            return null;
        }
        String wholeStr = spannableStringBuilder.toString();
        if (!TextUtils.isEmpty(wholeStr) && !TextUtils.isEmpty(keyStr) && strStyleType != null) {
            if (!matchCase) {
                wholeStr = wholeStr.toLowerCase();
                keyStr = keyStr.toLowerCase();
            }
            if (wholeStr.contains(keyStr)) {
                int start = wholeStr.indexOf(keyStr);
                int end = start + keyStr.length();
                while (start >= 0 && end <= wholeStr.length() && start < end) {
                    CharacterStyle characterStyle = null;
                    switch (strStyleType) {
                        case STR_COLOR:
                            characterStyle = new ForegroundColorSpan(keyStrValue);
                            break;
                        case STR_BG_COLOR:
                            characterStyle = new BackgroundColorSpan(keyStrValue);
                            break;
                        case STR_SIZE:
                            characterStyle = new AbsoluteSizeSpan(keyStrValue);
                            break;
                        case STR_BOLD:
                            characterStyle = new StyleSpan(Typeface.BOLD);
                            break;
                        case STR_ITALIC:
                            characterStyle = new StyleSpan(Typeface.ITALIC);
                            break;
                        case STR_BOLD_ITALIC:
                            characterStyle = new StyleSpan(Typeface.BOLD_ITALIC);
                            break;
                        case STR_STRIKETHROUGH:
                            characterStyle = new StrikethroughSpan();
                            break;
                        case STR_UNDERLINE:
                            characterStyle = new UnderlineSpan();
                            break;
                    }
                    if (characterStyle != null) {
                        spannableStringBuilder.setSpan(characterStyle, start, end, Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
                    }
                    if (end == wholeStr.length()) {
                        break;
                    }
                    start = wholeStr.indexOf(keyStr, end);
                    end = start + keyStr.length();
                }
            }
        }
        return spannableStringBuilder;
    }

    /**
     * 多个关键字
     * 设置在wholeStr中第一次出现的keyStr的颜色
     *
     * @param wholeStr  全部文字
     * @param keyStrMap key：关键字；Value：颜色
     * @param matchCase true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrColorFirst(String wholeStr, Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrColorFirst(new SpannableStringBuilder(wholeStr), keyStrMap, matchCase);
    }

    /**
     * 多个关键字
     * 设置在spannableStringBuilder中第一次出现的keyStr的颜色
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStrMap              key：关键字；Value：颜色
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrColorFirst(SpannableStringBuilder spannableStringBuilder
            , Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrStyleFirst(spannableStringBuilder, keyStrMap, StrStyleType.STR_COLOR, matchCase);
    }

    /**
     * 多个关键字
     * 设置在wholeStr中第一次出现的keyStr的背景颜色
     *
     * @param wholeStr  全部文字
     * @param keyStrMap key：关键字；Value：颜色
     * @param matchCase true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrBgColorFirst(String wholeStr, Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrBgColorFirst(new SpannableStringBuilder(wholeStr), keyStrMap, matchCase);
    }

    /**
     * 多个关键字
     * 设置在spannableStringBuilder中第一次出现的keyStr的背景颜色
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStrMap              key：关键字；Value：颜色
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrBgColorFirst(SpannableStringBuilder spannableStringBuilder
            , Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrStyleFirst(spannableStringBuilder, keyStrMap, StrStyleType.STR_BG_COLOR, matchCase);
    }

    /**
     * 多个关键字
     * 设置在wholeStr中第一次出现的keyStr的字号
     *
     * @param wholeStr  全部文字
     * @param keyStrMap key：关键字；Value：字号，单位pixels
     * @param matchCase true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrSizeFirst(String wholeStr, Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrSizeFirst(new SpannableStringBuilder(wholeStr), keyStrMap, matchCase);
    }

    /**
     * 多个关键字
     * 设置在spannableStringBuilder中第一次出现的keyStr的字号
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStrMap              key：关键字；Value：字号，单位pixels
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrSizeFirst(SpannableStringBuilder spannableStringBuilder
            , Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrStyleFirst(spannableStringBuilder, keyStrMap, StrStyleType.STR_SIZE, matchCase);
    }

    /**
     * 多个关键字
     * 设置在wholeStr中第一次出现的keyStr的样式
     *
     * @param wholeStr     全部文字
     * @param keyStrMap    key：关键字；Value：关键字值
     * @param strStyleType 字符串样式类型
     * @param matchCase    true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrStyleFirst(String wholeStr, Map<String, Integer> keyStrMap
            , StrStyleType strStyleType, boolean matchCase) {
        return fillStrStyleFirst(new SpannableStringBuilder(wholeStr), keyStrMap, strStyleType, matchCase);
    }

    /**
     * 多个关键字
     * 设置在spannableStringBuilder中第一次出现的keyStr的样式
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStrMap              key：关键字；Value：关键字值
     * @param strStyleType           字符串样式类型
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrStyleFirst(SpannableStringBuilder spannableStringBuilder
            , Map<String, Integer> keyStrMap, StrStyleType strStyleType, boolean matchCase) {
        if (spannableStringBuilder == null) {
            return null;
        }
        String wholeStr = spannableStringBuilder.toString();
        if (!TextUtils.isEmpty(wholeStr) && keyStrMap != null && keyStrMap.size() > 0 && strStyleType != null) {
            if (!matchCase) {
                wholeStr = wholeStr.toLowerCase();
            }
            Set<String> keySet = keyStrMap.keySet();
            for (String keyStr : keySet) {
                Integer keyStrValue = keyStrMap.get(keyStr);
                if (!TextUtils.isEmpty(keyStr) && keyStrValue != null) {
                    if (!matchCase) {
                        keyStr = keyStr.toLowerCase();
                    }
                    if (wholeStr.contains(keyStr)) {
                        CharacterStyle characterStyle = null;
                        switch (strStyleType) {
                            case STR_COLOR:
                                characterStyle = new ForegroundColorSpan(keyStrValue);
                                break;
                            case STR_BG_COLOR:
                                characterStyle = new BackgroundColorSpan(keyStrValue);
                                break;
                            case STR_SIZE:
                                characterStyle = new AbsoluteSizeSpan(keyStrValue);
                                break;
                            case STR_BOLD:
                                characterStyle = new StyleSpan(Typeface.BOLD);
                                break;
                            case STR_ITALIC:
                                characterStyle = new StyleSpan(Typeface.ITALIC);
                                break;
                            case STR_BOLD_ITALIC:
                                characterStyle = new StyleSpan(Typeface.BOLD_ITALIC);
                                break;
                            case STR_STRIKETHROUGH:
                                characterStyle = new StrikethroughSpan();
                                break;
                            case STR_UNDERLINE:
                                characterStyle = new UnderlineSpan();
                                break;
                        }
                        if (characterStyle != null) {
                            int start = wholeStr.indexOf(keyStr);
                            int end = start + keyStr.length();
                            spannableStringBuilder.setSpan(characterStyle, start, end, Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
                        }
                    }
                }
            }
        }
        return spannableStringBuilder;
    }

    /**
     * 多个关键字
     * 设置在wholeStr中出现的所有keyStr的颜色
     *
     * @param wholeStr  全部文字
     * @param keyStrMap key：关键字；Value：颜色
     * @param matchCase true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrColorAll(String wholeStr, Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrColorAll(new SpannableStringBuilder(wholeStr), keyStrMap, matchCase);
    }

    /**
     * 多个关键字
     * 设置在spannableStringBuilder中出现的所有keyStr的颜色
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStrMap              key：关键字；Value：颜色
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrColorAll(SpannableStringBuilder spannableStringBuilder
            , Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrStyleAll(spannableStringBuilder, keyStrMap, StrStyleType.STR_COLOR, matchCase);
    }

    /**
     * 多个关键字
     * 设置在wholeStr中出现的所有keyStr的背景颜色
     *
     * @param wholeStr  全部文字
     * @param keyStrMap key：关键字；Value：颜色
     * @param matchCase true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrBgColorAll(String wholeStr, Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrBgColorAll(new SpannableStringBuilder(wholeStr), keyStrMap, matchCase);
    }

    /**
     * 多个关键字
     * 设置在spannableStringBuilder中出现的所有keyStr的背景颜色
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStrMap              key：关键字；Value：颜色
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrBgColorAll(SpannableStringBuilder spannableStringBuilder
            , Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrStyleAll(spannableStringBuilder, keyStrMap, StrStyleType.STR_BG_COLOR, matchCase);
    }

    /**
     * 多个关键字
     * 设置在wholeStr中出现的所有keyStr的字号
     *
     * @param wholeStr  全部文字
     * @param keyStrMap key：关键字；Value：字号，单位pixels
     * @param matchCase true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrSizeAll(String wholeStr, Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrSizeAll(new SpannableStringBuilder(wholeStr), keyStrMap, matchCase);
    }

    /**
     * 多个关键字
     * 设置在spannableStringBuilder中出现的所有keyStr的字号
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStrMap              key：关键字；Value：字号，单位pixels
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrSizeAll(SpannableStringBuilder spannableStringBuilder
            , Map<String, Integer> keyStrMap, boolean matchCase) {
        return fillStrStyleAll(spannableStringBuilder, keyStrMap, StrStyleType.STR_SIZE, matchCase);
    }

    /**
     * 多个关键字
     * 设置在wholeStr中出现的所有keyStr的样式
     *
     * @param wholeStr     全部文字
     * @param keyStrMap    key：关键字；Value：关键字值
     * @param strStyleType 字符串样式类型
     * @param matchCase    true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrStyleAll(String wholeStr, Map<String, Integer> keyStrMap
            , StrStyleType strStyleType, boolean matchCase) {
        return fillStrStyleAll(new SpannableStringBuilder(wholeStr), keyStrMap, strStyleType, matchCase);
    }

    /**
     * 多个关键字
     * 设置在spannableStringBuilder中出现的所有keyStr的样式
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStrMap              key：关键字；Value：关键字值
     * @param strStyleType           字符串样式类型
     * @param matchCase              true：区分大小写；false：不区分大小写
     */
    public static SpannableStringBuilder fillStrStyleAll(SpannableStringBuilder spannableStringBuilder
            , Map<String, Integer> keyStrMap, StrStyleType strStyleType, boolean matchCase) {
        if (spannableStringBuilder == null) {
            return null;
        }
        String wholeStr = spannableStringBuilder.toString();
        if (!TextUtils.isEmpty(wholeStr) && keyStrMap != null && keyStrMap.size() > 0 && strStyleType != null) {
            if (!matchCase) {
                wholeStr = wholeStr.toLowerCase();
            }
            Set<String> keySet = keyStrMap.keySet();
            for (String keyStr : keySet) {
                Integer keyStrValue = keyStrMap.get(keyStr);
                if (!TextUtils.isEmpty(keyStr) && keyStrValue != null) {
                    if (!matchCase) {
                        keyStr = keyStr.toLowerCase();
                    }
                    if (wholeStr.contains(keyStr)) {
                        int start = wholeStr.indexOf(keyStr);
                        int end = start + keyStr.length();
                        while (start >= 0 && end <= wholeStr.length() && start < end) {
                            CharacterStyle characterStyle = null;
                            switch (strStyleType) {
                                case STR_COLOR:
                                    characterStyle = new ForegroundColorSpan(keyStrValue);
                                    break;
                                case STR_BG_COLOR:
                                    characterStyle = new BackgroundColorSpan(keyStrValue);
                                    break;
                                case STR_SIZE:
                                    characterStyle = new AbsoluteSizeSpan(keyStrValue);
                                    break;
                                case STR_BOLD:
                                    characterStyle = new StyleSpan(Typeface.BOLD);
                                    break;
                                case STR_ITALIC:
                                    characterStyle = new StyleSpan(Typeface.ITALIC);
                                    break;
                                case STR_BOLD_ITALIC:
                                    characterStyle = new StyleSpan(Typeface.BOLD_ITALIC);
                                    break;
                                case STR_STRIKETHROUGH:
                                    characterStyle = new StrikethroughSpan();
                                    break;
                                case STR_UNDERLINE:
                                    characterStyle = new UnderlineSpan();
                                    break;
                            }
                            if (characterStyle != null) {
                                spannableStringBuilder.setSpan(characterStyle, start, end, Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
                            }
                            if (end == wholeStr.length()) {
                                break;
                            }
                            start = wholeStr.indexOf(keyStr, end);
                            end = start + keyStr.length();
                        }
                    }
                }
            }
        }
        return spannableStringBuilder;
    }

    /**
     * 多个关键字
     * 设置指定位置的keyStr的颜色
     *
     * @param wholeStr       全部文字
     * @param keyStringInfos 关键字的一些信息（起始位置，结束位置，颜色值），包含起始位置不包含结束位置
     */
    public static SpannableStringBuilder fillStrColorByIndex(String wholeStr, List<StrStyleKeyBean> keyStringInfos) {
        return fillStrColorByIndex(new SpannableStringBuilder(wholeStr), keyStringInfos);
    }

    /**
     * 多个关键字
     * 设置指定位置的keyStr的颜色
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStringInfos         关键字的一些信息（起始位置，结束位置，颜色值），包含起始位置不包含结束位置
     */
    public static SpannableStringBuilder fillStrColorByIndex(SpannableStringBuilder spannableStringBuilder
            , List<StrStyleKeyBean> keyStringInfos) {
        return fillStrStyleByIndex(spannableStringBuilder, keyStringInfos, StrStyleType.STR_COLOR);
    }

    /**
     * 多个关键字
     * 设置指定位置的keyStr的背景颜色
     *
     * @param wholeStr       全部文字
     * @param keyStringInfos 关键字的一些信息（起始位置，结束位置，颜色值），包含起始位置不包含结束位置
     */
    public static SpannableStringBuilder fillStrBgColorByIndex(String wholeStr, List<StrStyleKeyBean> keyStringInfos) {
        return fillStrBgColorByIndex(new SpannableStringBuilder(wholeStr), keyStringInfos);
    }

    /**
     * 多个关键字
     * 设置指定位置的keyStr的背景颜色
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStringInfos         关键字的一些信息（起始位置，结束位置，颜色值），包含起始位置不包含结束位置
     */
    public static SpannableStringBuilder fillStrBgColorByIndex(SpannableStringBuilder spannableStringBuilder
            , List<StrStyleKeyBean> keyStringInfos) {
        return fillStrStyleByIndex(spannableStringBuilder, keyStringInfos, StrStyleType.STR_BG_COLOR);
    }

    /**
     * 多个关键字
     * 设置指定位置的keyStr的字号
     *
     * @param wholeStr       全部文字
     * @param keyStringInfos 关键字的一些信息（起始位置，结束位置，字号值单位pixels），包含起始位置不包含结束位置
     */
    public static SpannableStringBuilder fillStrSizeByIndex(String wholeStr, List<StrStyleKeyBean> keyStringInfos) {
        return fillStrSizeByIndex(new SpannableStringBuilder(wholeStr), keyStringInfos);
    }

    /**
     * 多个关键字
     * 设置指定位置的keyStr的字号
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStringInfos         关键字的一些信息（起始位置，结束位置，字号值单位pixels），包含起始位置不包含结束位置
     */
    public static SpannableStringBuilder fillStrSizeByIndex(SpannableStringBuilder spannableStringBuilder
            , List<StrStyleKeyBean> keyStringInfos) {
        return fillStrStyleByIndex(spannableStringBuilder, keyStringInfos, StrStyleType.STR_SIZE);
    }

    /**
     * 多个关键字
     * 设置指定位置的keyStr的样式
     *
     * @param wholeStr       全部文字
     * @param keyStringInfos 关键字的一些信息（起始位置，结束位置，关键字值），包含起始位置不包含结束位置
     * @param strStyleType   字符串样式类型
     */
    public static SpannableStringBuilder fillStrStyleByIndex(String wholeStr, List<StrStyleKeyBean> keyStringInfos
            , StrStyleType strStyleType) {
        return fillStrStyleByIndex(new SpannableStringBuilder(wholeStr), keyStringInfos, strStyleType);
    }

    /**
     * 多个关键字
     * 设置指定位置的keyStr的样式
     *
     * @param spannableStringBuilder 待处理数据
     * @param keyStringInfos         关键字的一些信息（起始位置，结束位置，关键字值），包含起始位置不包含结束位置
     * @param strStyleType           字符串样式类型
     */
    public static SpannableStringBuilder fillStrStyleByIndex(SpannableStringBuilder spannableStringBuilder
            , List<StrStyleKeyBean> keyStringInfos, StrStyleType strStyleType) {
        if (spannableStringBuilder == null) {
            return null;
        }
        String wholeStr = spannableStringBuilder.toString();
        if (!TextUtils.isEmpty(wholeStr) && keyStringInfos != null && keyStringInfos.size() > 0) {
            for (StrStyleKeyBean keyStringInfo : keyStringInfos) {
                int start = keyStringInfo.getStart();
                int end = keyStringInfo.getEnd();
                if (start >= 0 && end <= wholeStr.length() && start < end) {
                    CharacterStyle characterStyle = null;
                    switch (strStyleType) {
                        case STR_COLOR:
                            characterStyle = new ForegroundColorSpan(keyStringInfo.getValue());
                            break;
                        case STR_BG_COLOR:
                            characterStyle = new BackgroundColorSpan(keyStringInfo.getValue());
                            break;
                        case STR_SIZE:
                            characterStyle = new AbsoluteSizeSpan(keyStringInfo.getValue());
                            break;
                        case STR_BOLD:
                            characterStyle = new StyleSpan(Typeface.BOLD);
                            break;
                        case STR_ITALIC:
                            characterStyle = new StyleSpan(Typeface.ITALIC);
                            break;
                        case STR_BOLD_ITALIC:
                            characterStyle = new StyleSpan(Typeface.BOLD_ITALIC);
                            break;
                        case STR_STRIKETHROUGH:
                            characterStyle = new StrikethroughSpan();
                            break;
                        case STR_UNDERLINE:
                            characterStyle = new UnderlineSpan();
                            break;
                    }
                    if (characterStyle != null) {
                        spannableStringBuilder.setSpan(characterStyle, start, end, Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
                    }
                }
            }
        }
        return spannableStringBuilder;
    }

    /**
     * 标记颜色信息
     */
    public static class StrStyleKeyBean {
        // 起始位置，结束位置，颜色值
        int start;
        int end;
        int value;

        public StrStyleKeyBean(int start, int end, int value) {
            this.start = start;
            this.end = end;
            this.value = value;
        }

        public int getStart() {
            return start;
        }

        public void setStart(int start) {
            this.start = start;
        }

        public int getEnd() {
            return end;
        }

        public void setEnd(int end) {
            this.end = end;
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }
    }
}